home *** CD-ROM | disk | FTP | other *** search
/ Delphi 5 for Professionals / DELPHI5.iso / AddOns / Components / RealTime Graphics ActiveX / DATA.3 / Examples / CPP / PID / rtpidx.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-12-29  |  17.0 KB  |  884 lines
  1. // Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
  2.  
  3. // NOTE: Do not modify the contents of this file.  If this class is regenerated by
  4. //  Microsoft Visual C++, your modifications will be overwritten.
  5.  
  6.  
  7. #include "stdafx.h"
  8. #include "rtpidx.h"
  9.  
  10. /////////////////////////////////////////////////////////////////////////////
  11. // CRTPIDX
  12.  
  13. IMPLEMENT_DYNCREATE(CRTPIDX, CWnd)
  14.  
  15. /////////////////////////////////////////////////////////////////////////////
  16. // CRTPIDX properties
  17.  
  18. long CRTPIDX::GetWindowBackgroundColor()
  19. {
  20.     long result;
  21.     GetProperty(0x1, VT_I4, (void*)&result);
  22.     return result;
  23. }
  24.  
  25. void CRTPIDX::SetWindowBackgroundColor(long propVal)
  26. {
  27.     SetProperty(0x1, VT_I4, propVal);
  28. }
  29.  
  30. long CRTPIDX::GetWindowBorderColor()
  31. {
  32.     long result;
  33.     GetProperty(0x2, VT_I4, (void*)&result);
  34.     return result;
  35. }
  36.  
  37. void CRTPIDX::SetWindowBorderColor(long propVal)
  38. {
  39.     SetProperty(0x2, VT_I4, propVal);
  40. }
  41.  
  42. long CRTPIDX::GetPlotBackgroundColor()
  43. {
  44.     long result;
  45.     GetProperty(0x3, VT_I4, (void*)&result);
  46.     return result;
  47. }
  48.  
  49. void CRTPIDX::SetPlotBackgroundColor(long propVal)
  50. {
  51.     SetProperty(0x3, VT_I4, propVal);
  52. }
  53.  
  54. long CRTPIDX::GetWindowBorderStyle()
  55. {
  56.     long result;
  57.     GetProperty(0x4, VT_I4, (void*)&result);
  58.     return result;
  59. }
  60.  
  61. void CRTPIDX::SetWindowBorderStyle(long propVal)
  62. {
  63.     SetProperty(0x4, VT_I4, propVal);
  64. }
  65.  
  66. double CRTPIDX::GetTopPlotArea()
  67. {
  68.     double result;
  69.     GetProperty(0x5, VT_R8, (void*)&result);
  70.     return result;
  71. }
  72.  
  73. void CRTPIDX::SetTopPlotArea(double propVal)
  74. {
  75.     SetProperty(0x5, VT_R8, propVal);
  76. }
  77.  
  78. double CRTPIDX::GetRightPlotArea()
  79. {
  80.     double result;
  81.     GetProperty(0x6, VT_R8, (void*)&result);
  82.     return result;
  83. }
  84.  
  85. void CRTPIDX::SetRightPlotArea(double propVal)
  86. {
  87.     SetProperty(0x6, VT_R8, propVal);
  88. }
  89.  
  90. double CRTPIDX::GetLeftPlotArea()
  91. {
  92.     double result;
  93.     GetProperty(0x7, VT_R8, (void*)&result);
  94.     return result;
  95. }
  96.  
  97. void CRTPIDX::SetLeftPlotArea(double propVal)
  98. {
  99.     SetProperty(0x7, VT_R8, propVal);
  100. }
  101.  
  102. long CRTPIDX::GetWindowResizeMode()
  103. {
  104.     long result;
  105.     GetProperty(0x8, VT_I4, (void*)&result);
  106.     return result;
  107. }
  108.  
  109. void CRTPIDX::SetWindowResizeMode(long propVal)
  110. {
  111.     SetProperty(0x8, VT_I4, propVal);
  112. }
  113.  
  114. long CRTPIDX::GetWindowBorderThickness()
  115. {
  116.     long result;
  117.     GetProperty(0x9, VT_I4, (void*)&result);
  118.     return result;
  119. }
  120.  
  121. void CRTPIDX::SetWindowBorderThickness(long propVal)
  122. {
  123.     SetProperty(0x9, VT_I4, propVal);
  124. }
  125.  
  126. double CRTPIDX::GetBottomPlotArea()
  127. {
  128.     double result;
  129.     GetProperty(0xa, VT_R8, (void*)&result);
  130.     return result;
  131. }
  132.  
  133. void CRTPIDX::SetBottomPlotArea(double propVal)
  134. {
  135.     SetProperty(0xa, VT_R8, propVal);
  136. }
  137.  
  138. BOOL CRTPIDX::GetBarAutoPosition()
  139. {
  140.     BOOL result;
  141.     GetProperty(0xb, VT_BOOL, (void*)&result);
  142.     return result;
  143. }
  144.  
  145. void CRTPIDX::SetBarAutoPosition(BOOL propVal)
  146. {
  147.     SetProperty(0xb, VT_BOOL, propVal);
  148. }
  149.  
  150. double CRTPIDX::GetPIDDerivGain()
  151. {
  152.     double result;
  153.     GetProperty(0xc, VT_R8, (void*)&result);
  154.     return result;
  155. }
  156.  
  157. void CRTPIDX::SetPIDDerivGain(double propVal)
  158. {
  159.     SetProperty(0xc, VT_R8, propVal);
  160. }
  161.  
  162. double CRTPIDX::GetPIDFilterConstant()
  163. {
  164.     double result;
  165.     GetProperty(0xd, VT_R8, (void*)&result);
  166.     return result;
  167. }
  168.  
  169. void CRTPIDX::SetPIDFilterConstant(double propVal)
  170. {
  171.     SetProperty(0xd, VT_R8, propVal);
  172. }
  173.  
  174. double CRTPIDX::GetPIDInputHighValue()
  175. {
  176.     double result;
  177.     GetProperty(0xe, VT_R8, (void*)&result);
  178.     return result;
  179. }
  180.  
  181. void CRTPIDX::SetPIDInputHighValue(double propVal)
  182. {
  183.     SetProperty(0xe, VT_R8, propVal);
  184. }
  185.  
  186. double CRTPIDX::GetPIDInputLowValue()
  187. {
  188.     double result;
  189.     GetProperty(0xf, VT_R8, (void*)&result);
  190.     return result;
  191. }
  192.  
  193. void CRTPIDX::SetPIDInputLowValue(double propVal)
  194. {
  195.     SetProperty(0xf, VT_R8, propVal);
  196. }
  197.  
  198. double CRTPIDX::GetPIDIntegralGain()
  199. {
  200.     double result;
  201.     GetProperty(0x10, VT_R8, (void*)&result);
  202.     return result;
  203. }
  204.  
  205. void CRTPIDX::SetPIDIntegralGain(double propVal)
  206. {
  207.     SetProperty(0x10, VT_R8, propVal);
  208. }
  209.  
  210. double CRTPIDX::GetPIDOutputHighClamp()
  211. {
  212.     double result;
  213.     GetProperty(0x11, VT_R8, (void*)&result);
  214.     return result;
  215. }
  216.  
  217. void CRTPIDX::SetPIDOutputHighClamp(double propVal)
  218. {
  219.     SetProperty(0x11, VT_R8, propVal);
  220. }
  221.  
  222. double CRTPIDX::GetPIDOutputHighValue()
  223. {
  224.     double result;
  225.     GetProperty(0x12, VT_R8, (void*)&result);
  226.     return result;
  227. }
  228.  
  229. void CRTPIDX::SetPIDOutputHighValue(double propVal)
  230. {
  231.     SetProperty(0x12, VT_R8, propVal);
  232. }
  233.  
  234. double CRTPIDX::GetPIDOutputLowClamp()
  235. {
  236.     double result;
  237.     GetProperty(0x13, VT_R8, (void*)&result);
  238.     return result;
  239. }
  240.  
  241. void CRTPIDX::SetPIDOutputLowClamp(double propVal)
  242. {
  243.     SetProperty(0x13, VT_R8, propVal);
  244. }
  245.  
  246. double CRTPIDX::GetPIDOutputLowValue()
  247. {
  248.     double result;
  249.     GetProperty(0x14, VT_R8, (void*)&result);
  250.     return result;
  251. }
  252.  
  253. void CRTPIDX::SetPIDOutputLowValue(double propVal)
  254. {
  255.     SetProperty(0x14, VT_R8, propVal);
  256. }
  257.  
  258. double CRTPIDX::GetPIDOutputRateClamp()
  259. {
  260.     double result;
  261.     GetProperty(0x15, VT_R8, (void*)&result);
  262.     return result;
  263. }
  264.  
  265. void CRTPIDX::SetPIDOutputRateClamp(double propVal)
  266. {
  267.     SetProperty(0x15, VT_R8, propVal);
  268. }
  269.  
  270. double CRTPIDX::GetPIDOutputSteadyState()
  271. {
  272.     double result;
  273.     GetProperty(0x16, VT_R8, (void*)&result);
  274.     return result;
  275. }
  276.  
  277. void CRTPIDX::SetPIDOutputSteadyState(double propVal)
  278. {
  279.     SetProperty(0x16, VT_R8, propVal);
  280. }
  281.  
  282. double CRTPIDX::GetPIDSamplePeriod()
  283. {
  284.     double result;
  285.     GetProperty(0x17, VT_R8, (void*)&result);
  286.     return result;
  287. }
  288.  
  289. void CRTPIDX::SetPIDSamplePeriod(double propVal)
  290. {
  291.     SetProperty(0x17, VT_R8, propVal);
  292. }
  293.  
  294. double CRTPIDX::GetPIDSetpoint()
  295. {
  296.     double result;
  297.     GetProperty(0x18, VT_R8, (void*)&result);
  298.     return result;
  299. }
  300.  
  301. void CRTPIDX::SetPIDSetpoint(double propVal)
  302. {
  303.     SetProperty(0x18, VT_R8, propVal);
  304. }
  305.  
  306. double CRTPIDX::GetPIDPropGain()
  307. {
  308.     double result;
  309.     GetProperty(0x19, VT_R8, (void*)&result);
  310.     return result;
  311. }
  312.  
  313. void CRTPIDX::SetPIDPropGain(double propVal)
  314. {
  315.     SetProperty(0x19, VT_R8, propVal);
  316. }
  317.  
  318. BOOL CRTPIDX::GetPIDInvertedOutput()
  319. {
  320.     BOOL result;
  321.     GetProperty(0x1a, VT_BOOL, (void*)&result);
  322.     return result;
  323. }
  324.  
  325. void CRTPIDX::SetPIDInvertedOutput(BOOL propVal)
  326. {
  327.     SetProperty(0x1a, VT_BOOL, propVal);
  328. }
  329.  
  330. CString CRTPIDX::GetPIDLabelsFont()
  331. {
  332.     CString result;
  333.     GetProperty(0x1b, VT_BSTR, (void*)&result);
  334.     return result;
  335. }
  336.  
  337. void CRTPIDX::SetPIDLabelsFont(LPCTSTR propVal)
  338. {
  339.     SetProperty(0x1b, VT_BSTR, propVal);
  340. }
  341.  
  342. long CRTPIDX::GetPIDLabelsSize()
  343. {
  344.     long result;
  345.     GetProperty(0x1c, VT_I4, (void*)&result);
  346.     return result;
  347. }
  348.  
  349. void CRTPIDX::SetPIDLabelsSize(long propVal)
  350. {
  351.     SetProperty(0x1c, VT_I4, propVal);
  352. }
  353.  
  354. long CRTPIDX::GetPIDLabelsFontStyle()
  355. {
  356.     long result;
  357.     GetProperty(0x1d, VT_I4, (void*)&result);
  358.     return result;
  359. }
  360.  
  361. void CRTPIDX::SetPIDLabelsFontStyle(long propVal)
  362. {
  363.     SetProperty(0x1d, VT_I4, propVal);
  364. }
  365.  
  366. CString CRTPIDX::GetPIDAutoString()
  367. {
  368.     CString result;
  369.     GetProperty(0x1e, VT_BSTR, (void*)&result);
  370.     return result;
  371. }
  372.  
  373. void CRTPIDX::SetPIDAutoString(LPCTSTR propVal)
  374. {
  375.     SetProperty(0x1e, VT_BSTR, propVal);
  376. }
  377.  
  378. CString CRTPIDX::GetPIDManualString()
  379. {
  380.     CString result;
  381.     GetProperty(0x1f, VT_BSTR, (void*)&result);
  382.     return result;
  383. }
  384.  
  385. void CRTPIDX::SetPIDManualString(LPCTSTR propVal)
  386. {
  387.     SetProperty(0x1f, VT_BSTR, propVal);
  388. }
  389.  
  390. CString CRTPIDX::GetPIDNormalString()
  391. {
  392.     CString result;
  393.     GetProperty(0x20, VT_BSTR, (void*)&result);
  394.     return result;
  395. }
  396.  
  397. void CRTPIDX::SetPIDNormalString(LPCTSTR propVal)
  398. {
  399.     SetProperty(0x20, VT_BSTR, propVal);
  400. }
  401.  
  402. double CRTPIDX::GetPIDInputCenterValue()
  403. {
  404.     double result;
  405.     GetProperty(0x21, VT_R8, (void*)&result);
  406.     return result;
  407. }
  408.  
  409. void CRTPIDX::SetPIDInputCenterValue(double propVal)
  410. {
  411.     SetProperty(0x21, VT_R8, propVal);
  412. }
  413.  
  414. long CRTPIDX::GetPIDInputPrecision()
  415. {
  416.     long result;
  417.     GetProperty(0x22, VT_I4, (void*)&result);
  418.     return result;
  419. }
  420.  
  421. void CRTPIDX::SetPIDInputPrecision(long propVal)
  422. {
  423.     SetProperty(0x22, VT_I4, propVal);
  424. }
  425.  
  426. double CRTPIDX::GetPIDOutputCenterValue()
  427. {
  428.     double result;
  429.     GetProperty(0x23, VT_R8, (void*)&result);
  430.     return result;
  431. }
  432.  
  433. void CRTPIDX::SetPIDOutputCenterValue(double propVal)
  434. {
  435.     SetProperty(0x23, VT_R8, propVal);
  436. }
  437.  
  438. long CRTPIDX::GetPIDOutputPrecision()
  439. {
  440.     long result;
  441.     GetProperty(0x24, VT_I4, (void*)&result);
  442.     return result;
  443. }
  444.  
  445. void CRTPIDX::SetPIDOutputPrecision(long propVal)
  446. {
  447.     SetProperty(0x24, VT_I4, propVal);
  448. }
  449.  
  450. CString CRTPIDX::GetPIDInputUnits()
  451. {
  452.     CString result;
  453.     GetProperty(0x25, VT_BSTR, (void*)&result);
  454.     return result;
  455. }
  456.  
  457. void CRTPIDX::SetPIDInputUnits(LPCTSTR propVal)
  458. {
  459.     SetProperty(0x25, VT_BSTR, propVal);
  460. }
  461.  
  462. long CRTPIDX::GetPIDLabelsColor()
  463. {
  464.     long result;
  465.     GetProperty(0x26, VT_I4, (void*)&result);
  466.     return result;
  467. }
  468.  
  469. void CRTPIDX::SetPIDLabelsColor(long propVal)
  470. {
  471.     SetProperty(0x26, VT_I4, propVal);
  472. }
  473.  
  474. CString CRTPIDX::GetPIDOutputUnits()
  475. {
  476.     CString result;
  477.     GetProperty(0x27, VT_BSTR, (void*)&result);
  478.     return result;
  479. }
  480.  
  481. void CRTPIDX::SetPIDOutputUnits(LPCTSTR propVal)
  482. {
  483.     SetProperty(0x27, VT_BSTR, propVal);
  484. }
  485.  
  486. BOOL CRTPIDX::GetPIDBargraphEnable()
  487. {
  488.     BOOL result;
  489.     GetProperty(0x28, VT_BOOL, (void*)&result);
  490.     return result;
  491. }
  492.  
  493. void CRTPIDX::SetPIDBargraphEnable(BOOL propVal)
  494. {
  495.     SetProperty(0x28, VT_BOOL, propVal);
  496. }
  497.  
  498. double CRTPIDX::GetPIDManualOutputValue()
  499. {
  500.     double result;
  501.     GetProperty(0x29, VT_R8, (void*)&result);
  502.     return result;
  503. }
  504.  
  505. void CRTPIDX::SetPIDManualOutputValue(double propVal)
  506. {
  507.     SetProperty(0x29, VT_R8, propVal);
  508. }
  509.  
  510. long CRTPIDX::GetPIDNormalAlarmColor()
  511. {
  512.     long result;
  513.     GetProperty(0x2a, VT_I4, (void*)&result);
  514.     return result;
  515. }
  516.  
  517. void CRTPIDX::SetPIDNormalAlarmColor(long propVal)
  518. {
  519.     SetProperty(0x2a, VT_I4, propVal);
  520. }
  521.  
  522. long CRTPIDX::GetPIDLowAlarmColor()
  523. {
  524.     long result;
  525.     GetProperty(0x2b, VT_I4, (void*)&result);
  526.     return result;
  527. }
  528.  
  529. void CRTPIDX::SetPIDLowAlarmColor(long propVal)
  530. {
  531.     SetProperty(0x2b, VT_I4, propVal);
  532. }
  533.  
  534. long CRTPIDX::GetPIDHighAlarmColor()
  535. {
  536.     long result;
  537.     GetProperty(0x2c, VT_I4, (void*)&result);
  538.     return result;
  539. }
  540.  
  541. void CRTPIDX::SetPIDHighAlarmColor(long propVal)
  542. {
  543.     SetProperty(0x2c, VT_I4, propVal);
  544. }
  545.  
  546. BOOL CRTPIDX::GetPIDAlarmMessageEnable()
  547. {
  548.     BOOL result;
  549.     GetProperty(0x2d, VT_BOOL, (void*)&result);
  550.     return result;
  551. }
  552.  
  553. void CRTPIDX::SetPIDAlarmMessageEnable(BOOL propVal)
  554. {
  555.     SetProperty(0x2d, VT_BOOL, propVal);
  556. }
  557.  
  558. CString CRTPIDX::GetPIDHighAlarmString()
  559. {
  560.     CString result;
  561.     GetProperty(0x2e, VT_BSTR, (void*)&result);
  562.     return result;
  563. }
  564.  
  565. void CRTPIDX::SetPIDHighAlarmString(LPCTSTR propVal)
  566. {
  567.     SetProperty(0x2e, VT_BSTR, propVal);
  568. }
  569.  
  570. double CRTPIDX::GetPIDHighAlarmValue()
  571. {
  572.     double result;
  573.     GetProperty(0x2f, VT_R8, (void*)&result);
  574.     return result;
  575. }
  576.  
  577. void CRTPIDX::SetPIDHighAlarmValue(double propVal)
  578. {
  579.     SetProperty(0x2f, VT_R8, propVal);
  580. }
  581.  
  582. CString CRTPIDX::GetPIDLowAlarmString()
  583. {
  584.     CString result;
  585.     GetProperty(0x30, VT_BSTR, (void*)&result);
  586.     return result;
  587. }
  588.  
  589. void CRTPIDX::SetPIDLowAlarmString(LPCTSTR propVal)
  590. {
  591.     SetProperty(0x30, VT_BSTR, propVal);
  592. }
  593.  
  594. double CRTPIDX::GetPIDLowAlarmValue()
  595. {
  596.     double result;
  597.     GetProperty(0x31, VT_R8, (void*)&result);
  598.     return result;
  599. }
  600.  
  601. void CRTPIDX::SetPIDLowAlarmValue(double propVal)
  602. {
  603.     SetProperty(0x31, VT_R8, propVal);
  604. }
  605.  
  606. CString CRTPIDX::GetPIDNormalAlarmString()
  607. {
  608.     CString result;
  609.     GetProperty(0x32, VT_BSTR, (void*)&result);
  610.     return result;
  611. }
  612.  
  613. void CRTPIDX::SetPIDNormalAlarmString(LPCTSTR propVal)
  614. {
  615.     SetProperty(0x32, VT_BSTR, propVal);
  616. }
  617.  
  618. double CRTPIDX::GetPIDInputValue()
  619. {
  620.     double result;
  621.     GetProperty(0x33, VT_R8, (void*)&result);
  622.     return result;
  623. }
  624.  
  625. void CRTPIDX::SetPIDInputValue(double propVal)
  626. {
  627.     SetProperty(0x33, VT_R8, propVal);
  628. }
  629.  
  630. double CRTPIDX::GetPIDOutputValue()
  631. {
  632.     double result;
  633.     GetProperty(0x34, VT_R8, (void*)&result);
  634.     return result;
  635. }
  636.  
  637. void CRTPIDX::SetPIDOutputValue(double propVal)
  638. {
  639.     SetProperty(0x34, VT_R8, propVal);
  640. }
  641.  
  642. BOOL CRTPIDX::GetEnableInternalTimer()
  643. {
  644.     BOOL result;
  645.     GetProperty(0x35, VT_BOOL, (void*)&result);
  646.     return result;
  647. }
  648.  
  649. void CRTPIDX::SetEnableInternalTimer(BOOL propVal)
  650. {
  651.     SetProperty(0x35, VT_BOOL, propVal);
  652. }
  653.  
  654. double CRTPIDX::GetTimerFrequency()
  655. {
  656.     double result;
  657.     GetProperty(0x36, VT_R8, (void*)&result);
  658.     return result;
  659. }
  660.  
  661. void CRTPIDX::SetTimerFrequency(double propVal)
  662. {
  663.     SetProperty(0x36, VT_R8, propVal);
  664. }
  665.  
  666. BOOL CRTPIDX::GetSDataSimulationMode()
  667. {
  668.     BOOL result;
  669.     GetProperty(0x37, VT_BOOL, (void*)&result);
  670.     return result;
  671. }
  672.  
  673. void CRTPIDX::SetSDataSimulationMode(BOOL propVal)
  674. {
  675.     SetProperty(0x37, VT_BOOL, propVal);
  676. }
  677.  
  678. /////////////////////////////////////////////////////////////////////////////
  679. // CRTPIDX operations
  680.  
  681. CString CRTPIDX::GetTitleString(long title)
  682. {
  683.     CString result;
  684.     static BYTE parms[] =
  685.         VTS_I4;
  686.     InvokeHelper(0x3e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  687.         title);
  688.     return result;
  689. }
  690.  
  691. void CRTPIDX::SetTitleString(long title, LPCTSTR lpszNewValue)
  692. {
  693.     static BYTE parms[] =
  694.         VTS_I4 VTS_BSTR;
  695.     InvokeHelper(0x3e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  696.          title, lpszNewValue);
  697. }
  698.  
  699. CString CRTPIDX::GetTitleFont(long title)
  700. {
  701.     CString result;
  702.     static BYTE parms[] =
  703.         VTS_I4;
  704.     InvokeHelper(0x3f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  705.         title);
  706.     return result;
  707. }
  708.  
  709. void CRTPIDX::SetTitleFont(long title, LPCTSTR lpszNewValue)
  710. {
  711.     static BYTE parms[] =
  712.         VTS_I4 VTS_BSTR;
  713.     InvokeHelper(0x3f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  714.          title, lpszNewValue);
  715. }
  716.  
  717. long CRTPIDX::GetTitleColor(long title)
  718. {
  719.     long result;
  720.     static BYTE parms[] =
  721.         VTS_I4;
  722.     InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  723.         title);
  724.     return result;
  725. }
  726.  
  727. void CRTPIDX::SetTitleColor(long title, long nNewValue)
  728. {
  729.     static BYTE parms[] =
  730.         VTS_I4 VTS_I4;
  731.     InvokeHelper(0x40, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  732.          title, nNewValue);
  733. }
  734.  
  735. long CRTPIDX::GetTitleFontStyle(long title)
  736. {
  737.     long result;
  738.     static BYTE parms[] =
  739.         VTS_I4;
  740.     InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  741.         title);
  742.     return result;
  743. }
  744.  
  745. void CRTPIDX::SetTitleFontStyle(long title, long nNewValue)
  746. {
  747.     static BYTE parms[] =
  748.         VTS_I4 VTS_I4;
  749.     InvokeHelper(0x41, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  750.          title, nNewValue);
  751. }
  752.  
  753. long CRTPIDX::GetTitleFontSize(long title)
  754. {
  755.     long result;
  756.     static BYTE parms[] =
  757.         VTS_I4;
  758.     InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  759.         title);
  760.     return result;
  761. }
  762.  
  763. void CRTPIDX::SetTitleFontSize(long title, long nNewValue)
  764. {
  765.     static BYTE parms[] =
  766.         VTS_I4 VTS_I4;
  767.     InvokeHelper(0x42, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  768.          title, nNewValue);
  769. }
  770.  
  771. long CRTPIDX::GetPIDChannelColor(long nChannel)
  772. {
  773.     long result;
  774.     static BYTE parms[] =
  775.         VTS_I4;
  776.     InvokeHelper(0x43, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  777.         nChannel);
  778.     return result;
  779. }
  780.  
  781. void CRTPIDX::SetPIDChannelColor(long nChannel, long nNewValue)
  782. {
  783.     static BYTE parms[] =
  784.         VTS_I4 VTS_I4;
  785.     InvokeHelper(0x43, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  786.          nChannel, nNewValue);
  787. }
  788.  
  789. CString CRTPIDX::GetPIDTagName(long nChannel)
  790. {
  791.     CString result;
  792.     static BYTE parms[] =
  793.         VTS_I4;
  794.     InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  795.         nChannel);
  796.     return result;
  797. }
  798.  
  799. void CRTPIDX::SetPIDTagName(long nChannel, LPCTSTR lpszNewValue)
  800. {
  801.     static BYTE parms[] =
  802.         VTS_I4 VTS_BSTR;
  803.     InvokeHelper(0x44, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  804.          nChannel, lpszNewValue);
  805. }
  806.  
  807. double CRTPIDX::CalcPID(double rInput)
  808. {
  809.     double result;
  810.     static BYTE parms[] =
  811.         VTS_R8;
  812.     InvokeHelper(0x38, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
  813.         rInput);
  814.     return result;
  815. }
  816.  
  817. double CRTPIDX::GetPIDChannelInitialValue(long nChannel)
  818. {
  819.     double result;
  820.     static BYTE parms[] =
  821.         VTS_I4;
  822.     InvokeHelper(0x45, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  823.         nChannel);
  824.     return result;
  825. }
  826.  
  827. void CRTPIDX::SetPIDChannelInitialValue(long nChannel, double newValue)
  828. {
  829.     static BYTE parms[] =
  830.         VTS_I4 VTS_R8;
  831.     InvokeHelper(0x45, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  832.          nChannel, newValue);
  833. }
  834.  
  835. void CRTPIDX::UpdatePIDBargraph(double rInputValue, double rSetpoint, double rOutputValue)
  836. {
  837.     static BYTE parms[] =
  838.         VTS_R8 VTS_R8 VTS_R8;
  839.     InvokeHelper(0x39, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  840.          rInputValue, rSetpoint, rOutputValue);
  841. }
  842.  
  843. BOOL CRTPIDX::SerializeLoadFile(LPCTSTR sFilename)
  844. {
  845.     BOOL result;
  846.     static BYTE parms[] =
  847.         VTS_BSTR;
  848.     InvokeHelper(0x3a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  849.         sFilename);
  850.     return result;
  851. }
  852.  
  853. BOOL CRTPIDX::SerializeSaveFile(LPCTSTR sFilename)
  854. {
  855.     BOOL result;
  856.     static BYTE parms[] =
  857.         VTS_BSTR;
  858.     InvokeHelper(0x3b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  859.         sFilename);
  860.     return result;
  861. }
  862.  
  863. BOOL CRTPIDX::CopyToClipboard()
  864. {
  865.     BOOL result;
  866.     InvokeHelper(0x3c, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  867.     return result;
  868. }
  869.  
  870. BOOL CRTPIDX::SavePageMeta(long mftype, LPCTSTR sFilename)
  871. {
  872.     BOOL result;
  873.     static BYTE parms[] =
  874.         VTS_I4 VTS_BSTR;
  875.     InvokeHelper(0x3d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  876.         mftype, sFilename);
  877.     return result;
  878. }
  879.  
  880. void CRTPIDX::AboutBox()
  881. {
  882.     InvokeHelper(0xfffffdd8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  883. }
  884.